package exam;

import java.util.*;

public class Main1 {
    public static void main(String[] args) {
        char a = 'a';
        char b = 'z';
        char c = 'A';
        char d = 'Z';
        char d1 = 'Z';
        char d4 = '0';
        char d5 = '9';
        System.out.println((int)a);
        System.out.println((int)b);
        System.out.println((int)c);
        System.out.println((int)d);
        System.out.println((int)d1);
        System.out.println((int)d4);
        System.out.println((int)d5);
    }

    //改动态规划
    public static long getMaxSumWithDP(int[][]rea){
        int h = rea.length;
        int[][]dp = new int[h+1][];   //dp表示h层 l位置时可以获得的最大值
        dp[h] = new int[2*h-1];
        for (int a=h-1;a>=0;a--){
            dp[a] = new int[2*a+1];
            for (int b = 0;b<2*a+1;b++){
                int maxNum = 0;
                maxNum = Math.max(dp[a+1][a],maxNum);
                maxNum = Math.max(dp[a+1][a+1],maxNum);
                maxNum = Math.max(dp[a+1][a+2],maxNum);
                System.out.println("a:"+a+"    b:"+b+"   "+dp[a].length);
                dp[a][b] = rea[a][b] + maxNum;
            }
        }
        return dp[0][0];
    }

/*
*
* 小团正在装饰自己的书桌，他的书桌上从左到右有m个空位需要放上装饰物。商店中每个整数价格的装饰物恰好有一种，且每种装饰物的数量无限多。

小团去商店的时候，想到了一个购买方案，他要让右边的装饰物价格是左边的倍数。用数学语言来说，假设小团的m个装饰物价格为a1,a2...am，那么对于任意的1≤i≤j≤m，aj是ai的倍数。

小团是一个节约的人，他希望最贵的装饰物不超过n元。现在，请你计算小团有多少种购买的方案？



输入描述
输入包含两个数，n和m（1≤n,m≤1000）

输出描述
输出一个数，结果对998244353取模，表示购买的方案数。


样例输入
4 2
样例输出
8

提示
样例解释
[1,1][1,2][1,3][1,4][2,2][2,4][3,3][4,4]共8种
规则
* */
        //字符串匹配
    public static int strStr(String haystack, String needle) {
        if (haystack.length()<needle.length()){
            return -1;
        }
        if (needle.length() == 0){
            return 0;
        }
        int len = needle.length();
        int end = len -1;
        while (end<haystack.length()){
            int begin = end - len+1;
            for (char c:needle.toCharArray()){
                if (c == haystack.charAt(begin)){
                    begin++;  //  4  5 6 7 8
                    if (begin == end+1){
                        return end - len+1;
                    }
                }
            }
            end++;
        }
        return -1;
    }

        //全排列
    public List<List<Integer>> permute(int[] nums) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int a: nums){
            arrayList.add(a);
        }
        return getAll(arrayList);
    }

    public static List<List<Integer>> getAll(ArrayList<Integer> arr){
            List<List<Integer>> res = new ArrayList<>();
        if (arr.size()==1){
            List<Integer> list  =  new ArrayList<>();
            list.add(arr.get(0));
            res.add(list);
            return res;
        }
        for (int a=0;a<arr.size();a++){
            ArrayList<Integer> arrayList= new ArrayList<>(arr);
            int temp = arrayList.remove(a);
            List<List<Integer>> l = getAll(arrayList);
            for (List<Integer> in :l){
                List<Integer> list = new ArrayList<>();
                list.add(temp);
                for (int n : in){
                    list.add(n);
                }
                res.add(list);
            }
        }
        return res;
    }


    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int a=0;a<nums.length-2;a++){
            if (a>0 && nums[a]==nums[a-1]){
                continue;
            }
            //-4 -1 -1 0 1 2 4
            for (int b=a+1;b<nums.length-1;b++){
                if (b>a+1 && nums[b]==nums[b-1]){
                    continue;
                }
                for (int c=b+1;c<nums.length;c++){
                    if (c>b+1 &&nums[c] == nums[c-1]){
                        continue;
                    }
                    if (  nums[a]+nums[b]+nums[c] == 0)
                    {
                        ArrayList<Integer> list = new ArrayList<>();
                        list.add(nums[a]);
                        list.add(nums[b]);
                        list.add(nums[c]);
                        res.add(list);
                    }
                }
            }
        }
        return res;

    }

        public static int getRes(int n,int m,int last){
            for (int a=1;a<=n;a++){

            }
            return 0;
        }

        public static int getMax(int[][] arr,int a, int b,ArrayList<Integer> arrayList){
            int[][] dp =new int[a+1][b+1];
            dp[0][0] = 0;
            int res = 0;
            return 0;

            /*if (a<=0 && b<=0){
                return 0;
            }
            int res = 0;
            for (int x=1;x<=arr.length;x++){
                if (!arrayList.contains(x)) {
                    ArrayList<Integer> newArr = new ArrayList<>(arrayList);
                    newArr.add(x);
                    res = Math.max(arr[x-1][0] + getMax(arr, a - 1, b, newArr),res);
                }
                if (!arrayList.contains(x)) {
                    ArrayList<Integer> newArr = new ArrayList<>(arrayList);
                    newArr.add(x);
                    res = Math.max(arr[x-1][0] + getMax(arr, a, b-1, newArr),res);
                }
            }
            return res;*/
        }

}
